// pages/order-detail/order-detail.js
Page({

  /**
   * 页面的初始数据
   */
  data: {
    order: null,
    loading: true,
    orderId: '',
    userInfo: null,
    isTeamUser: false, // 是否是施工队伍用户
    statusMap: {
      // 与订单列表页面完全对应的状态映射
      'waiting_team': { text: '待接单', color: '#FF6B35', bgColor: 'rgba(255, 107, 53, 0.1)' },
      'team_accepted': { text: '已接单', color: '#2196F3', bgColor: 'rgba(33, 150, 243, 0.1)' },
      'surveying': { text: '查勘中', color: '#9C27B0', bgColor: 'rgba(156, 39, 176, 0.1)' },
      'designing': { text: '设计中', color: '#673AB7', bgColor: 'rgba(103, 58, 183, 0.1)' },
      'quoted': { text: '已报价', color: '#3F51B5', bgColor: 'rgba(63, 81, 181, 0.1)' },
      'in_progress': { text: '施工中', color: '#2196F3', bgColor: 'rgba(33, 150, 243, 0.1)' },
      'testing': { text: '验收中', color: '#00BCD4', bgColor: 'rgba(0, 188, 212, 0.1)' },
      'completed': { text: '已完成', color: '#4CAF50', bgColor: 'rgba(76, 175, 80, 0.1)' },
      'cancelled': { text: '已取消', color: '#F44336', bgColor: 'rgba(244, 67, 54, 0.1)' },
      'cancel_pending': { text: '申请取消中', color: '#FF9800', bgColor: 'rgba(255, 152, 0, 0.1)' },
      
      // 兼容旧状态的映射
      'pending': { text: '待接单', color: '#FF6B35', bgColor: 'rgba(255, 107, 53, 0.1)' },
      'confirmed': { text: '已接单', color: '#2196F3', bgColor: 'rgba(33, 150, 243, 0.1)' },
      'team_preparing': { text: '已接单', color: '#2196F3', bgColor: 'rgba(33, 150, 243, 0.1)' },
      'team_on_site': { text: '施工中', color: '#2196F3', bgColor: 'rgba(33, 150, 243, 0.1)' },
      'paused': { text: '施工中', color: '#FF9800', bgColor: 'rgba(255, 152, 0, 0.1)' },
      'rejected': { text: '已取消', color: '#F44336', bgColor: 'rgba(244, 67, 54, 0.1)' },
      'reassigning': { text: '待接单', color: '#FF9800', bgColor: 'rgba(255, 152, 0, 0.1)' },
      'request_cancel': { text: '申请取消中', color: '#FF9800', bgColor: 'rgba(255, 152, 0, 0.1)' },
      
      // 英文状态映射
      'accepted': { text: '已接单', color: '#2196F3', bgColor: 'rgba(33, 150, 243, 0.1)' },
      'waiting': { text: '待接单', color: '#FF6B35', bgColor: 'rgba(255, 107, 53, 0.1)' },
      'progress': { text: '施工中', color: '#2196F3', bgColor: 'rgba(33, 150, 243, 0.1)' },
      'finished': { text: '已完成', color: '#4CAF50', bgColor: 'rgba(76, 175, 80, 0.1)' },
      'canceled': { text: '已取消', color: '#F44336', bgColor: 'rgba(244, 67, 54, 0.1)' }
    },
    urgencyMap: {
      // 标准紧急程度
      'low': { text: '一般', color: '#4CAF50' },
      'medium': { text: '紧急', color: '#FF9800' },
      'high': { text: '特急', color: '#F44336' },
      
      // 英文值映射
      'normal': { text: '一般', color: '#4CAF50' },
      'urgent': { text: '紧急', color: '#FF9800' },
      'emergency': { text: '特急', color: '#F44336' },
      
      // 数字值映射
      '1': { text: '一般', color: '#4CAF50' },
      '2': { text: '紧急', color: '#FF9800' },
      '3': { text: '特急', color: '#F44336' },
      
      // 其他可能的值
      'regular': { text: '一般', color: '#4CAF50' },
      'priority': { text: '紧急', color: '#FF9800' },
      'critical': { text: '特急', color: '#F44336' }
    },
    actionHistory: [],
    showCancelModal: false,
    cancelReason: '',
    cancelDetail: '',
    selectedReasonIndex: -1,
    cancellationReasons: [
      '计划变更，暂不需要此服务',
      '找到了其他服务商',
      '预算调整，无法继续',
      '时间安排冲突',
      '对报价不满意',
      '其他原因'
    ],
    // 取消按钮显示控制
    canCancelOrder: false,
    needTeamApprovalForCancel: false,
    showCancelButton: false
  },

  /**
   * 生命周期函数--监听页面加载
   */
  async onLoad(options) {
    console.log('📱 订单详情页加载，参数:', options)

    const { id } = options
    if (!id) {
      console.log('❌ 订单ID不存在')
      wx.showToast({
        title: '订单ID不存在',
        icon: 'none'
      })
      setTimeout(() => {
        wx.navigateBack()
      }, 1500)
      return
    }

    console.log('📋 订单ID:', id)
    this.setData({ orderId: id })

    // 先检查登录状态
    const loginResult = await this.checkLoginStatus()
    if (!loginResult.success) {
      console.log('❌ 用户未登录，显示登录提示')
      wx.showModal({
        title: '需要登录',
        content: '查看订单详情需要先登录，是否前往个人中心登录？',
        confirmText: '去登录',
        cancelText: '返回',
        success: (res) => {
          if (res.confirm) {
            // 保存当前页面信息到全局存储
            const returnUrl = `/pages/order-detail/order-detail?id=${this.data.orderId}`
            wx.setStorageSync('loginReturnUrl', returnUrl)
            console.log('保存返回URL到存储:', returnUrl)

            // 跳转到个人中心
            wx.switchTab({
              url: '/pages/profile/profile'
            })
          } else {
            wx.navigateBack()
          }
        }
      })
      return
    }

    console.log('✅ 登录状态验证通过，开始加载订单详情')
    
    // 设置用户信息和身份
    this.setData({
      userInfo: loginResult.userInfo,
      isTeamUser: this.checkIfTeamUser(loginResult.userInfo)
    })
    
    this.loadOrderDetail(id)
  },
  
  // 检查登录状态
  async checkLoginStatus() {
    try {
      // 检查本地存储的登录状态
      const isLoggedIn = wx.getStorageSync('isLoggedIn')
      const userInfo = wx.getStorageSync('userInfo')

      console.log('登录状态检查:', {
        isLoggedIn,
        hasUserInfo: !!userInfo,
        hasOpenid: !!(userInfo && userInfo.openid)
      })

      // 如果本地有登录状态和用户信息，认为已登录
      if (isLoggedIn && userInfo && userInfo.openid) {
        console.log('✅ 用户已登录，openid:', userInfo.openid)
        return { success: true, userInfo: userInfo }
      }

      return { success: false, error: '用户未登录' }
    } catch (error) {
      console.error('登录状态检查失败:', error)
      return { success: false, error: '登录状态检查失败' }
    }
  },

  // 检查是否是施工队伍用户
  checkIfTeamUser(userInfo) {
    // 检查用户是否有施工队伍相关的角色或权限
    if (userInfo && userInfo.roles) {
      return userInfo.roles.includes('team_member') || userInfo.roles.includes('team_leader')
    }
    
    // 也可以通过其他方式判断，比如检查是否有团队ID
    if (userInfo && userInfo.teamId) {
      return true
    }
    
    return false
  },

  // 检查用户是否可以取消订单
  canCancelOrder(order, userInfo) {
    if (!order || !userInfo) return false
    
    // 检查是否是订单的创建者
    const isOrderOwner = order.openid === userInfo.openid || order.customerOpenid === userInfo.openid
    if (!isOrderOwner) return false
    
    // 根据订单状态判断是否可以取消
    const cancelableStatuses = [
      'pending',      // 待处理 - 可以直接取消
      'confirmed',    // 已确认 - 可以直接取消
      'surveying',    // 查勘中 - 可以直接取消
      'designing',    // 设计中 - 可以直接取消
      'quoted',       // 已报价 - 可以直接取消
      'waiting_team'  // 等待接单 - 可以直接取消
    ]
    
    return cancelableStatuses.includes(order.status)
  },

  // 检查取消订单是否需要施工队伍同意
  needTeamApprovalForCancel(order) {
    if (!order) return false
    
    // 已接单及后续状态需要施工队伍同意
    const teamApprovalStatuses = [
      'team_accepted',  // 已接单
      'team_preparing', // 准备中
      'team_on_site',   // 到达现场
      'in_progress',    // 施工中
      'paused',         // 暂停施工
      'testing'         // 验收中
    ]
    
    return teamApprovalStatuses.includes(order.status)
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    this.loadOrderDetail(this.data.orderId)
    wx.stopPullDownRefresh()
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    const { order } = this.data
    return {
      title: `订单详情 - ${order?.customerName || '数智匠心工程'}`,
      path: `/pages/order-detail/order-detail?id=${this.data.orderId}`,
      imageUrl: '/images/share-order.jpg'
    }
  },

  // 服务图片加载成功
  onServiceImageLoad(e) {
    console.log('✅ 服务图片加载成功')
  },

  // 服务图片加载失败
  onServiceImageError(e) {
    console.log('❌ 服务图片加载失败:', e.detail)
    // 可以设置默认图片或隐藏图片容器
  },

  // 加载订单详情
  async loadOrderDetail(orderId) {
    console.log('🔍 开始加载订单详情，ID:', orderId)
    
    wx.showLoading({ title: '加载中...' })
    
    try {
      // 先尝试从本地存储获取
      const localOrders = wx.getStorageSync('orders') || []
      console.log('本地存储的订单数量:', localOrders.length)
      
      const localOrder = localOrders.find(order => order.id === orderId)
      
      if (localOrder) {
        console.log('✅ 从本地存储获取订单信息:', localOrder)
        
        // 预处理状态信息和时间
        const statusInfo = this.getStatusInfo(localOrder.status)
        const urgencyInfo = localOrder.urgency ? this.getUrgencyInfo(localOrder.urgency) : null
        
        // 调试时间字段
        console.log('🕐 订单时间字段检查:', {
          createTime: localOrder.createTime,
          _createTime: localOrder._createTime,
          createdAt: localOrder.createdAt,
          timestamp: localOrder.timestamp
        })
        
        const createTimeValue = localOrder.createTime || localOrder._createTime || localOrder.createdAt || localOrder.timestamp
        const formattedCreateTime = this.formatDate(createTimeValue)
        
        console.log('🕐 最终时间值:', createTimeValue, '格式化结果:', formattedCreateTime)
        
        // 计算取消按钮显示逻辑
        const canCancel = this.canCancelOrder(localOrder, this.data.userInfo)
        const needApproval = this.needTeamApprovalForCancel(localOrder)
        const showCancelButton = (canCancel || needApproval) && 
                                localOrder.status !== 'cancel_pending' && 
                                localOrder.status !== 'request_cancel'
        
        this.setData({
          order: localOrder,
          statusInfo: statusInfo,
          urgencyInfo: urgencyInfo,
          formattedCreateTime: formattedCreateTime,
          loading: false,
          canCancelOrder: canCancel,
          needTeamApprovalForCancel: needApproval,
          showCancelButton: showCancelButton
        })
        wx.hideLoading()
        
        // 设置页面标题
        wx.setNavigationBarTitle({
          title: `订单详情 - ${localOrder.customerName || localOrder.id}`
        })
        
        // 异步从云端更新数据
        this.refreshFromCloud(orderId)
        return
      } else {
        console.log('⚠️ 本地存储中未找到订单，将从云端获取')
        console.log('本地订单ID列表:', localOrders.map(o => o.id))
      }
      
      // 如果本地没有，从云端获取
      await this.refreshFromCloud(orderId)
      
    } catch (error) {
      wx.hideLoading()
      console.error('❌ 加载订单详情失败:', error)
      
      this.setData({ loading: false })
      
      wx.showModal({
        title: '加载失败',
        content: '无法获取订单信息，请检查网络连接后重试',
        showCancel: true,
        cancelText: '返回',
        confirmText: '重试',
        success: (res) => {
          if (res.confirm) {
            this.loadOrderDetail(orderId)
          } else {
            wx.navigateBack()
          }
        }
      })
    }
  },

  // 从云端刷新数据
  async refreshFromCloud(orderId) {
    try {
      console.log('☁️ 从云端获取订单信息...')
      console.log('订单ID:', orderId)
      
      // 获取用户信息用于调试
      const userInfo = wx.getStorageSync('userInfo')
      console.log('当前用户信息:', userInfo ? userInfo.openid : '无用户信息')
      
      const result = await wx.cloud.callFunction({
        name: 'businessManager',
        data: {
          action: 'getOrderDetail',
          data: { orderId }
        }
      })

      console.log('云函数返回结果:', result)
      wx.hideLoading()

      if (result.result && result.result.success) {
        const order = result.result.data
        console.log('✅ 云端订单信息获取成功:', order)

        // 调试信息：显示服务关联
        console.log('📋 完整订单数据:', order)

        if (order.serviceId) {
          console.log('🔗 订单关联的服务ID:', order.serviceId)
        } else {
          console.log('⚠️ 订单没有serviceId字段')
        }

        if (order.serviceInfo) {
          console.log('🔗 订单关联的服务信息:', order.serviceInfo)
          console.log('🖼️ 服务图片URL:', order.serviceInfo.image)
          // 将serviceInfo映射到service字段，便于模板使用
          order.service = order.serviceInfo
        } else {
          console.log('⚠️ 订单没有serviceInfo字段')
        }

        if (order.service) {
          console.log('🔗 订单关联的服务详情:', order.service)
          console.log('🖼️ 最终服务图片URL:', order.service.image)
        } else {
          console.log('⚠️ 订单没有service字段')
        }

        // 预处理状态信息和时间
        const statusInfo = this.getStatusInfo(order.status)
        const urgencyInfo = order.urgency ? this.getUrgencyInfo(order.urgency) : null
        
        // 调试时间字段
        console.log('🕐 云端订单时间字段检查:', {
          createTime: order.createTime,
          _createTime: order._createTime,
          createdAt: order.createdAt,
          timestamp: order.timestamp
        })
        
        const createTimeValue = order.createTime || order._createTime || order.createdAt || order.timestamp
        const formattedCreateTime = this.formatDate(createTimeValue)
        
        console.log('🕐 云端最终时间值:', createTimeValue, '格式化结果:', formattedCreateTime)
        
        // 计算取消按钮显示逻辑
        const canCancel = this.canCancelOrder(order, this.data.userInfo)
        const needApproval = this.needTeamApprovalForCancel(order)
        const showCancelButton = (canCancel || needApproval) && 
                                order.status !== 'cancel_pending' && 
                                order.status !== 'request_cancel'
        
        // 调试：打印取消相关信息
        if (order.status === 'cancelled' || order.status === 'canceled' || order.status === 'rejected') {
          console.log('🚫 取消订单信息调试:', {
            status: order.status,
            cancelReason: order.cancelReason,
            cancelTime: order.cancelTime,
            cancelBy: order.cancelBy,
            cancelNote: order.cancelNote,
            cancelRequestReason: order.cancelRequestReason,
            cancelRequestTime: order.cancelRequestTime
          })
        }
        
        // 格式化所有时间字段
        if (order.cancelTime) {
          order.cancelTimeFormatted = this.formatDate(order.cancelTime)
        }
        if (order.cancelRequestTime) {
          order.cancelRequestTimeFormatted = this.formatDate(order.cancelRequestTime)
        }
        if (order.updateTime) {
          order.updateTimeFormatted = this.formatDate(order.updateTime)
        }
        if (order.acceptTime) {
          order.acceptTimeFormatted = this.formatDate(order.acceptTime)
        }
        if (order.expectedDate) {
          order.expectedDateFormatted = this.formatDate(order.expectedDate)
        }
        if (order.quotation && order.quotation.validUntil) {
          order.quotation.validUntilFormatted = this.formatDate(order.quotation.validUntil)
        }
        
        // 添加调试信息
        const debugOrderFields = Object.keys(order).join(', ')
        
        this.setData({
          order: order,
          statusInfo: statusInfo,
          urgencyInfo: urgencyInfo,
          formattedCreateTime: formattedCreateTime,
          loading: false,
          canCancelOrder: canCancel,
          needTeamApprovalForCancel: needApproval,
          showCancelButton: showCancelButton,
          debugOrderFields: debugOrderFields
        })
        
        // 更新页面标题
        wx.setNavigationBarTitle({
          title: `订单详情 - ${order.customerName || order.id}`
        })
        
        // 获取操作历史
        this.loadActionHistory(orderId)
        
      } else {
        const errorMsg = result.result ? result.result.error : '云函数返回格式错误'
        console.error('云函数返回错误:', errorMsg)
        throw new Error(errorMsg || '获取订单信息失败')
      }
      
    } catch (error) {
      wx.hideLoading()
      console.error('❌ 云端获取失败:', error)
      console.error('错误详情:', error.message)
      console.error('错误堆栈:', error.stack)
      
      // 如果云端获取失败，显示错误信息
      this.setData({ loading: false })
      
      // 显示具体的错误信息
      let errorMsg = '获取订单信息失败'
      if (error.message.includes('订单不存在')) {
        errorMsg = '订单不存在或无权限查看'
      } else if (error.message.includes('网络')) {
        errorMsg = '网络连接失败，请检查网络'
      } else if (error.message.includes('cloud function')) {
        errorMsg = '服务暂不可用，请稍后重试'
      }
      
      wx.showModal({
        title: '加载失败',
        content: errorMsg,
        showCancel: true,
        cancelText: '返回',
        confirmText: '重试',
        success: (res) => {
          if (res.confirm) {
            this.refreshFromCloud(orderId)
          } else {
            wx.navigateBack()
          }
        }
      })
    }
  },

  // 加载操作历史
  async loadActionHistory(orderId) {
    try {
      const result = await wx.cloud.callFunction({
        name: 'businessManager',
        data: {
          action: 'getOrderHistory',
          data: { orderId }
        }
      })

      if (result.result.success) {
        const actionHistory = result.result.data || []
        // 格式化操作历史中的时间
        actionHistory.forEach(item => {
          if (item.createTime) {
            item.createTimeFormatted = this.formatDate(item.createTime)
          }
        })
        
        this.setData({
          actionHistory: actionHistory
        })
      }
    } catch (error) {
      console.error('获取操作历史失败:', error)
    }
  },

  // 格式化日期
  formatDate(dateStr) {
    if (!dateStr) return ''
    
    try {
      let date
      
      // 处理不同的日期格式
      if (typeof dateStr === 'string') {
        // 如果是字符串，尝试解析
        date = new Date(dateStr)
      } else if (dateStr instanceof Date) {
        // 如果已经是Date对象
        date = dateStr
      } else if (typeof dateStr === 'number') {
        // 如果是时间戳
        date = new Date(dateStr)
      } else {
        // 其他类型，尝试转换
        date = new Date(String(dateStr))
      }
      
      // 检查日期是否有效
      if (isNaN(date.getTime())) {
        console.warn('❌ 无效的日期格式:', dateStr)
        return String(dateStr) // 返回原始字符串
      }
      
      // 手动格式化，确保兼容性
      const year = date.getFullYear()
      const month = String(date.getMonth() + 1).padStart(2, '0')
      const day = String(date.getDate()).padStart(2, '0')
      const hours = String(date.getHours()).padStart(2, '0')
      const minutes = String(date.getMinutes()).padStart(2, '0')
      
      return `${year}年${month}月${day}日 ${hours}:${minutes}`
      
    } catch (error) {
      console.error('❌ 格式化日期失败:', error, '原始数据:', dateStr)
      return String(dateStr) // 返回原始字符串
    }
  },

  // 获取状态信息
  getStatusInfo(status) {
    if (!status) {
      return { text: '待接单', color: '#FF6B35', bgColor: 'rgba(255, 107, 53, 0.1)' } // 默认状态
    }
    
    // 转换为小写进行匹配
    const lowerStatus = String(status).toLowerCase()
    
    // 先尝试直接匹配
    if (this.data.statusMap[status]) {
      return this.data.statusMap[status]
    }
    
    // 再尝试小写匹配
    if (this.data.statusMap[lowerStatus]) {
      return this.data.statusMap[lowerStatus]
    }
    
    // 智能识别英文状态关键词
    if (lowerStatus.includes('accept') || lowerStatus.includes('confirm')) {
      return { text: '已接单', color: '#2196F3', bgColor: 'rgba(33, 150, 243, 0.1)' }
    } else if (lowerStatus.includes('wait') || lowerStatus.includes('pend')) {
      return { text: '待接单', color: '#FF6B35', bgColor: 'rgba(255, 107, 53, 0.1)' }
    } else if (lowerStatus.includes('progress') || lowerStatus.includes('working') || lowerStatus.includes('construction')) {
      return { text: '施工中', color: '#2196F3', bgColor: 'rgba(33, 150, 243, 0.1)' }
    } else if (lowerStatus.includes('complete') || lowerStatus.includes('finish') || lowerStatus.includes('done')) {
      return { text: '已完成', color: '#4CAF50', bgColor: 'rgba(76, 175, 80, 0.1)' }
    } else if (lowerStatus.includes('cancel') || lowerStatus.includes('reject')) {
      return { text: '已取消', color: '#F44336', bgColor: 'rgba(244, 67, 54, 0.1)' }
    } else if (lowerStatus.includes('survey') || lowerStatus.includes('inspect')) {
      return { text: '查勘中', color: '#9C27B0', bgColor: 'rgba(156, 39, 176, 0.1)' }
    } else if (lowerStatus.includes('design')) {
      return { text: '设计中', color: '#673AB7', bgColor: 'rgba(103, 58, 183, 0.1)' }
    } else if (lowerStatus.includes('quot') || lowerStatus.includes('price')) {
      return { text: '已报价', color: '#3F51B5', bgColor: 'rgba(63, 81, 181, 0.1)' }
    } else if (lowerStatus.includes('test') || lowerStatus.includes('check')) {
      return { text: '验收中', color: '#00BCD4', bgColor: 'rgba(0, 188, 212, 0.1)' }
    } else {
      // 如果都匹配不到，返回默认状态
      return { text: '待接单', color: '#666', bgColor: 'rgba(102, 102, 102, 0.1)' }
    }
  },

  // 获取紧急程度信息
  getUrgencyInfo(urgency) {
    if (!urgency) {
      return { text: '一般', color: '#4CAF50' } // 默认为一般
    }
    
    // 转换为小写进行匹配
    const lowerUrgency = String(urgency).toLowerCase()
    
    // 先尝试直接匹配
    if (this.data.urgencyMap[urgency]) {
      return this.data.urgencyMap[urgency]
    }
    
    // 再尝试小写匹配
    if (this.data.urgencyMap[lowerUrgency]) {
      return this.data.urgencyMap[lowerUrgency]
    }
    
    // 如果都没匹配到，根据内容智能判断
    if (lowerUrgency.includes('high') || lowerUrgency.includes('urgent') || lowerUrgency.includes('emergency') || lowerUrgency.includes('特急') || lowerUrgency.includes('紧急')) {
      return { text: '特急', color: '#F44336' }
    } else if (lowerUrgency.includes('medium') || lowerUrgency.includes('中等') || lowerUrgency.includes('较急')) {
      return { text: '紧急', color: '#FF9800' }
    } else {
      return { text: '一般', color: '#4CAF50' }
    }
  },

  // 显示取消订单弹窗
  showCancelOrder() {
    const { order, userInfo } = this.data
    
    if (!this.canCancelOrder(order, userInfo)) {
      wx.showToast({
        title: '当前状态不可取消',
        icon: 'none'
      })
      return
    }
    
    // 检查是否需要施工队伍同意
    if (this.needTeamApprovalForCancel(order)) {
      wx.showModal({
        title: '取消订单确认',
        content: '此订单已被施工队伍接单，取消需要获得施工队伍同意。您确定要申请取消吗？',
        confirmText: '申请取消',
        cancelText: '暂不取消',
        success: (res) => {
          if (res.confirm) {
            this.setData({ showCancelModal: true })
          }
        }
      })
    } else {
      // 直接显示取消原因选择
      this.setData({ showCancelModal: true })
    }
  },

  // 隐藏取消订单弹窗
  hideCancelModal() {
    this.setData({ 
      showCancelModal: false,
      cancelReason: '',
      cancelDetail: '',
      selectedReasonIndex: -1
    })
  },

  // 显示取消原因选择器
  showReasonSelector() {
    wx.showActionSheet({
      itemList: this.data.cancellationReasons,
      success: (res) => {
        const selectedReason = this.data.cancellationReasons[res.tapIndex]
        
        this.setData({
          cancelReason: selectedReason,
          selectedReasonIndex: res.tapIndex
        })
        
        wx.showToast({
          title: `已选择`,
          icon: 'success',
          duration: 1000
        })
      }
    })
  },

  // 选择取消原因
  onCancelReasonChange(e) {
    console.log('🔽 取消原因选择事件触发:', e)
    console.log('📋 可选原因列表:', this.data.cancellationReasons)
    
    const index = e.detail.value
    const selectedReason = this.data.cancellationReasons[index]
    
    console.log('✅ 选择的原因:', `索引${index} - ${selectedReason}`)
    
    this.setData({
      cancelReason: selectedReason,
      selectedReasonIndex: index
    })
    
    wx.showToast({
      title: `已选择: ${selectedReason}`,
      icon: 'none',
      duration: 1000
    })
  },

  // 输入取消详细说明
  onCancelDetailInput(e) {
    this.setData({
      cancelDetail: e.detail.value
    })
  },

  // 确认取消订单
  async confirmCancelOrder() {
    const { order, userInfo, cancelReason, cancelDetail, needTeamApprovalForCancel } = this.data
    
    if (!cancelReason) {
      wx.showToast({
        title: '请选择取消原因',
        icon: 'none'
      })
      return
    }
    
    wx.showLoading({ title: '处理中...' })
    
    try {
      const needApproval = needTeamApprovalForCancel
      
      // 组合完整的取消原因
      let fullReason = cancelReason
      if (cancelDetail && cancelDetail.trim()) {
        fullReason += `（${cancelDetail.trim()}）`
      }
      
      console.log('🔄 调用取消订单云函数:', {
        action: needApproval ? 'requestCancelOrder' : 'cancelOrder',
        orderId: this.data.orderId,
        reason: fullReason,
        needTeamApproval: needApproval
      })
      
      const result = await wx.cloud.callFunction({
        name: 'businessManager',
        data: {
          action: needApproval ? 'requestCancelOrder' : 'cancelOrder',
          data: {
            orderId: this.data.orderId,
            reason: fullReason,
            needTeamApproval: needApproval
          }
        }
      })
      
      console.log('📋 取消订单云函数返回:', result)

      wx.hideLoading()

      if (result.result.success) {
        wx.showToast({
          title: needApproval ? '取消申请已提交' : '订单已取消',
          icon: 'success'
        })
        
        this.hideCancelModal()
        
        // 刷新订单数据
        this.loadOrderDetail(this.data.orderId)
        
        // 如果是申请取消，显示提示信息
        if (needApproval) {
          setTimeout(() => {
            wx.showModal({
              title: '申请已提交',
              content: '您的取消申请已提交给施工队伍，请等待对方确认。我们会通过消息通知您处理结果。',
              showCancel: false
            })
          }, 1500)
        } else {
          // 直接取消成功，可以显示感谢信息
          setTimeout(() => {
            wx.showModal({
              title: '订单已取消',
              content: '感谢您的反馈，我们会持续改进服务质量。如有其他需要，欢迎随时联系我们。',
              showCancel: false,
              confirmText: '知道了'
            })
          }, 1500)
        }
      } else {
        wx.showToast({
          title: result.result.error || '操作失败',
          icon: 'none'
        })
      }
    } catch (error) {
      wx.hideLoading()
      console.error('取消订单失败:', error)
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none'
      })
    }
  },

  // 联系施工队伍
  contactTeam() {
    const { order } = this.data
    if (!order || !order.teamPhone) {
      wx.showToast({
        title: '施工队伍联系方式不存在',
        icon: 'none'
      })
      return
    }

    wx.showActionSheet({
      itemList: ['拨打电话', '发送短信'],
      success: (res) => {
        switch (res.tapIndex) {
          case 0:
            this.makePhoneCall(order.teamPhone)
            break
          case 1:
            this.sendSMS(order.teamPhone)
            break
        }
      }
    })
  },

  // 拨打电话
  makePhoneCall(phone) {
    wx.makePhoneCall({
      phoneNumber: phone,
      fail: () => {
        wx.showToast({
          title: '拨号失败',
          icon: 'none'
        })
      }
    })
  },

  // 发送短信
  sendSMS(phone) {
    wx.showModal({
      title: '发送短信',
      content: `将打开短信应用发送到：${phone}`,
      success: (res) => {
        if (res.confirm) {
          // 微信小程序无法直接发送短信，提示用户手动操作
          wx.setClipboardData({
            data: phone,
            success: () => {
              wx.showToast({
                title: '号码已复制',
                icon: 'success'
              })
            }
          })
        }
      }
    })
  },



  // 查看项目详情
  viewProjectDetail() {
    const { order } = this.data
    if (order.projectId) {
      wx.navigateTo({
        url: `/pages/project-detail/project-detail?id=${order.projectId}`
      })
    } else {
      wx.showToast({
        title: '项目信息不存在',
        icon: 'none'
      })
    }
  },

  // 订单评价
  rateOrder() {
    const { order } = this.data
    
    if (order.status !== 'completed') {
      wx.showToast({
        title: '订单完成后才能评价',
        icon: 'none'
      })
      return
    }
    
    wx.navigateTo({
      url: `/pages/order-rating/order-rating?orderId=${this.data.orderId}`
    })
  },

  // 申请售后
  requestAfterSales() {
    const { order } = this.data
    
    if (!['completed', 'testing'].includes(order.status)) {
      wx.showToast({
        title: '当前状态不支持售后申请',
        icon: 'none'
      })
      return
    }
    
    wx.navigateTo({
      url: `/pages/after-sales/after-sales?orderId=${this.data.orderId}`
    })
  },

  // 处理微信客服联系事件
  handleContact(e) {
    console.log('📞 用户联系客服:', e.detail)
    console.log('📱 客服路径:', e.detail.path)
    console.log('📋 查询参数:', e.detail.query)
    
    // 给用户反馈
    wx.showToast({
      title: '正在连接客服...',
      icon: 'loading',
      duration: 1000
    })
    
    // 记录客服联系行为
    try {
      wx.cloud.callFunction({
        name: 'businessManager',
        data: {
          action: 'logCustomerService',
          data: {
            orderId: this.data.orderId,
            type: 'contact_service',
            source: 'order_detail',
            note: `用户从订单详情页联系客服，订单号：${this.data.orderId}`,
            detail: e.detail
          }
        }
      }).then(result => {
        console.log('📊 客服联系记录成功:', result)
      }).catch(error => {
        console.warn('📊 客服联系记录失败:', error)
      })
    } catch (error) {
      console.warn('📊 记录客服联系失败:', error)
    }
    
    // 微信会自动打开客服会话界面
    console.log('✅ 客服会话将自动打开')
  },

  // 阻止事件冒泡（用于弹窗内部点击）
  stopPropagation() {
    // 空方法，用于阻止事件冒泡
  }
})